// utils/auth.js - 用户认证模块
const api = require('./api.js');
const config = require('./config.js');

class AuthService {
  constructor() {
    this.isLoginning = false;
  }

  /**
   * 检查登录状态
   */
  checkLoginStatus() {
    const token = wx.getStorageSync(config.APP_CONFIG.STORAGE_KEYS.TOKEN);
    const userInfo = wx.getStorageSync(config.APP_CONFIG.STORAGE_KEYS.USER_INFO);
    
    return {
      isLogin: !!(token && userInfo),
      token,
      userInfo
    };
  }

  /**
   * 微信授权登录
   */
  async wechatLogin(userInfo = {}) {
    if (this.isLoginning) {
      throw new Error('正在登录中，请稍候...');
    }

    this.isLoginning = true;

    try {
      // 1. 获取微信登录凭证
      const loginResult = await this.getWechatLoginCode();
      
      // 2. 调用后端登录接口
      const response = await api.wechatLogin(loginResult.code, userInfo);
      
      if (response.success) {
        const { token, userInfo: serverUserInfo } = response.data;
        
        // 3. 保存登录信息到本地
        wx.setStorageSync(config.APP_CONFIG.STORAGE_KEYS.TOKEN, token);
        wx.setStorageSync(config.APP_CONFIG.STORAGE_KEYS.USER_INFO, {
          ...userInfo,
          ...serverUserInfo,
          loginTime: Date.now()
        });

        console.log('微信登录成功:', serverUserInfo);
        return {
          success: true,
          data: serverUserInfo
        };
      } else {
        throw new Error(response.message || '登录失败');
      }
    } catch (error) {
      console.error('微信登录失败:', error);
      throw error;
    } finally {
      this.isLoginning = false;
    }
  }

  /**
   * 获取微信登录凭证
   */
  getWechatLoginCode() {
    return new Promise((resolve, reject) => {
      wx.login({
        success: (res) => {
          if (res.code) {
            resolve(res);
          } else {
            reject(new Error('获取登录凭证失败'));
          }
        },
        fail: (error) => {
          reject(new Error('微信登录失败: ' + error.errMsg));
        }
      });
    });
  }

  /**
   * 获取用户信息（新版本兼容）
   */
  getUserProfile() {
    return new Promise((resolve, reject) => {
      // 检查是否支持 getUserProfile
      if (wx.getUserProfile) {
        wx.getUserProfile({
          desc: '用于完善用户资料',
          success: (res) => {
            resolve(res.userInfo);
          },
          fail: (error) => {
            reject(new Error('获取用户信息失败: ' + error.errMsg));
          }
        });
      } else {
        // 兼容旧版本
        wx.getUserInfo({
          success: (res) => {
            resolve(res.userInfo);
          },
          fail: (error) => {
            reject(new Error('获取用户信息失败: ' + error.errMsg));
          }
        });
      }
    });
  }

  /**
   * 完整的登录流程
   */
  async login() {
    try {
      // 1. 获取用户信息
      const userInfo = await this.getUserProfile();
      
      // 2. 执行微信登录
      const loginResult = await this.wechatLogin(userInfo);
      
      return loginResult;
    } catch (error) {
      console.error('登录流程失败:', error);
      throw error;
    }
  }

  /**
   * 静默登录（仅使用code）
   */
  async silentLogin() {
    try {
      const loginResult = await this.wechatLogin();
      return loginResult;
    } catch (error) {
      console.error('静默登录失败:', error);
      throw error;
    }
  }

  /**
   * 退出登录
   */
  logout() {
    // 清除本地存储的用户信息
    wx.removeStorageSync(config.APP_CONFIG.STORAGE_KEYS.TOKEN);
    wx.removeStorageSync(config.APP_CONFIG.STORAGE_KEYS.USER_INFO);
    wx.removeStorageSync(config.APP_CONFIG.STORAGE_KEYS.VIP_INFO);
    
    // 可以选择性清除其他数据
    // wx.removeStorageSync(config.APP_CONFIG.STORAGE_KEYS.CHAT_HISTORY);
    // wx.removeStorageSync(config.APP_CONFIG.STORAGE_KEYS.FAVORITES);
    
    console.log('用户已退出登录');
    
    return {
      success: true,
      message: '退出登录成功'
    };
  }

  /**
   * 更新用户信息
   */
  async updateUserInfo(newUserInfo) {
    try {
      const response = await api.updateUserInfo(newUserInfo);
      
      if (response.success) {
        // 更新本地存储的用户信息
        const currentUserInfo = wx.getStorageSync(config.APP_CONFIG.STORAGE_KEYS.USER_INFO) || {};
        const updatedUserInfo = {
          ...currentUserInfo,
          ...response.data,
          updateTime: Date.now()
        };
        
        wx.setStorageSync(config.APP_CONFIG.STORAGE_KEYS.USER_INFO, updatedUserInfo);
        
        return {
          success: true,
          data: updatedUserInfo
        };
      } else {
        throw new Error(response.message || '更新用户信息失败');
      }
    } catch (error) {
      console.error('更新用户信息失败:', error);
      throw error;
    }
  }

  /**
   * 刷新用户信息
   */
  async refreshUserInfo() {
    try {
      const response = await api.getUserInfo();
      
      if (response.success) {
        const currentUserInfo = wx.getStorageSync(config.APP_CONFIG.STORAGE_KEYS.USER_INFO) || {};
        const refreshedUserInfo = {
          ...currentUserInfo,
          ...response.data,
          refreshTime: Date.now()
        };
        
        wx.setStorageSync(config.APP_CONFIG.STORAGE_KEYS.USER_INFO, refreshedUserInfo);
        
        return {
          success: true,
          data: refreshedUserInfo
        };
      } else {
        throw new Error(response.message || '刷新用户信息失败');
      }
    } catch (error) {
      console.error('刷新用户信息失败:', error);
      throw error;
    }
  }

  /**
   * 检查token是否过期
   */
  isTokenExpired() {
    const userInfo = wx.getStorageSync(config.APP_CONFIG.STORAGE_KEYS.USER_INFO);
    if (!userInfo || !userInfo.loginTime) {
      return true;
    }
    
    // 检查是否超过7天未登录（可配置）
    const expireTime = 7 * 24 * 60 * 60 * 1000; // 7天
    return (Date.now() - userInfo.loginTime) > expireTime;
  }

  /**
   * 自动登录检查
   */
  async autoLoginCheck() {
    const loginStatus = this.checkLoginStatus();
    
    if (!loginStatus.isLogin) {
      // 未登录，尝试静默登录
      try {
        return await this.silentLogin();
      } catch (error) {
        console.log('静默登录失败，需要用户主动登录');
        return { success: false, needLogin: true };
      }
    } else if (this.isTokenExpired()) {
      // token过期，刷新用户信息
      try {
        return await this.refreshUserInfo();
      } catch (error) {
        console.log('刷新用户信息失败，需要重新登录');
        this.logout();
        return { success: false, needLogin: true };
      }
    } else {
      // 已登录且未过期
      return {
        success: true,
        data: loginStatus.userInfo
      };
    }
  }

  /**
   * 显示登录弹窗
   */
  showLoginModal(options = {}) {
    const { title = '登录提示', content = '此功能需要登录后使用，是否立即登录？' } = options;
    
    return new Promise((resolve, reject) => {
      wx.showModal({
        title: title,
        content: content,
        confirmText: '立即登录',
        cancelText: '暂不登录',
        success: async (res) => {
          if (res.confirm) {
            try {
              const loginResult = await this.login();
              resolve(loginResult);
            } catch (error) {
              wx.showToast({
                title: '登录失败',
                icon: 'none'
              });
              reject(error);
            }
          } else {
            reject(new Error('用户取消登录'));
          }
        },
        fail: (error) => {
          reject(error);
        }
      });
    });
  }
}

// 创建单例实例
const authService = new AuthService();

module.exports = authService;
